package com.example.demo.service.serviceImpl;

import com.alibaba.fastjson.JSON;
import com.example.demo.entity.BackResponseEntity;
import com.example.demo.entity.Login;
import com.example.demo.entity.requestJson.CodeLoginReq;
import com.example.demo.entity.requestJson.LoginReq;
import com.example.demo.entity.responseJson.LoginRes;
import com.example.demo.enums.ErrCodeEnum;
import com.example.demo.mapper.LoginMapper;
import com.example.demo.service.LoginService;
import com.example.demo.tools.Md5utils;
import com.example.demo.tools.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;

import java.util.List;
import java.util.UUID;

/**
 * 登录信息表(Login)Service层
 *
 * @author makejava
 * @since 2021-02-25 15:12:18
 */
@Service
@Transactional(rollbackFor = {RuntimeException.class, Exception.class})
public class ULoginServiceImpl implements LoginService {
        @Autowired
        private LoginMapper loginMapper;
        @Autowired
        private RedisUtil redisUtil;


 /**
     * 通过ID和其他条件查询单条数据
     *
     * @param login 实例对象
     * @return 实例对象
     */
       @Override
 @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
     public Login queryLoginLimit1(Login login){
     return  loginMapper.queryLoginLimit1( login);
     }
     
 /**
     * 查询指定行数据
     * @param login 实例对象
     * @param offset 查询起始位置
     * @param limit 查询条数
     * @return 对象列表
     */
       @Override
 @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
  public   List<Login> queryAllLoginByLimit( Login login, Integer offset,  Integer limit){
   return loginMapper.queryAllLoginByLimit(login, offset,limit);
  }

  /**
     * 查询数据条数
     * @return 条数
     */
       @Override
 @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
   public int countAllLogin(Login login){
   return loginMapper.countAllLogin( login);
   }
   /**
     * 通过实体作为筛选条件查询
     *
     * @param login 实例对象
     * @return 对象列表
     */
       @Override
 @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
   public List<Login> queryAllLogin(Login login){
   return loginMapper.queryAllLogin(login);
   }
  /**
     * 新增数据
     *
     * @param login 实例对象
     * @return 影响行数
     */
     @Override
   @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
    public int insertLogin(Login login){
    return  loginMapper.insertLogin( login);
    }
  /**
     * 修改数据
     *
     * @param login 实例对象
     * @return 影响行数
     */
       @Override
 @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
     public  int updateLogin(Login login){
         return loginMapper.updateLogin( login);
     }

    /**
     * 通过主键删除数据
     * @param loginId 主键
     * @return 影响行数
     */
      @Override
  @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
   public  int deleteLoginById(String loginId){
   return  loginMapper.deleteLoginById( loginId);
   }
     /**
     * 通过主键列表删除，列表长度不能为0
     * @param list 集合
     * @return 条数
     */
      @Override
  @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
  public  int deleteLoginByIds( List<String> list){
    return  loginMapper.deleteLoginByIds(  list);
  }
    
       /**
     * 通过主键修改实体列表，列表长度不能为0，注意：当实体属性为null时，对应的列也会别更新为null
     * @param list 集合
     * @return 条数
     */
       @Override
 @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
   public int updateLoginBatch( List<Login> list){
   return  loginMapper.updateLoginBatch(list);
   }
    /**
     * 批量其他列,除主键以外的列，列表长度不能为0,字段是空的就置为null
     * @param list 集合
     * @return 条数
     */
      @Override
  @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
 public   int insertLoginBatch( List<Login> list){
 return loginMapper.insertLoginBatch( list);
 }
      /**
     * 通过实体非空属性删除
     * @param login  实体
     * @return 条数
     */
        @Override
@Transactional(rollbackFor = {RuntimeException.class, Exception.class})
  public   int deleteLoginByEntity( Login login){
  return  loginMapper.deleteLoginByEntity(  login);
  }
    /**
     * 通过实体不为空的属性作为筛选条件查询列表
     * @param login  实体
     * @return list
     */
       @Override
 @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
   public  List<Login> listLoginByEntity(Login login){
   return loginMapper.listLoginByEntity( login);
   }

 /**
     * 新增实体属性不为null的列
     * @param login  实体
     * @return 条数
     */
       @Override
 @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
   public  int insertLoginSelect( Login login){
      return loginMapper.insertLoginSelect( login);

   }
   
      /**
     * 批量新增新增实体属性不为null的列
     * @param list  实体
     * @return 条数
     */
        @Override
@Transactional(rollbackFor = {RuntimeException.class, Exception.class})
  public  int insertLoginListSelect( List<Login> list){

     return loginMapper.insertLoginListSelect( list);
      }
     /**
     * 通过实体不为空的属性作为筛选条件查询单个
     * @param login  实体
     * @return 单个
     */
     @Override
   @Transactional(rollbackFor = {RuntimeException.class, Exception.class})
    public  Login getLoginByEntity(Login login){
     return  loginMapper.getLoginByEntity(login);
    }

    /**
     * 读者端登录，默认传的role为1
     * 如果登录表中角色不为1，为0（即作家端账号），则会报错无此用户*/
    @Override
    public BackResponseEntity<LoginRes> doLogin(LoginReq loginReq){
        if (ObjectUtils.isEmpty(loginReq.getAccount()) || ObjectUtils.isEmpty(loginReq.getLoginpwd()) || ObjectUtils.isEmpty(loginReq.getRole())) {
            return BackResponseEntity.success(ErrCodeEnum.unknown_4006, "抱歉，参数缺失");
        }

        String md5Pwd = Md5utils.getmd5Lowercase("qingyu" + loginReq.getLoginpwd());
        Login login = loginMapper.queryByAccount(loginReq.getAccount());

        if (ObjectUtils.isEmpty(login) || login.getLoginRole() != 1) {
            return BackResponseEntity.success(ErrCodeEnum.unknown_1005, "抱歉，用户不存在!");
        }


        if (!login.getLoginPwd().equals(md5Pwd)) {
            return BackResponseEntity.success(ErrCodeEnum.unknown_1006, "抱歉，用户账号或密码错误");
        }

        String token = UUID.randomUUID()
                .toString();
        LoginRes loginRes = new LoginRes();
        redisUtil.set(token + ":users", JSON.toJSONString(login), 60 * 30);

        loginRes.setToken(token);
        loginRes.setNickname(login.getLoginNickname());
        loginRes.setImg(login.getLoginPic());
        return BackResponseEntity.success(ErrCodeEnum.unknown_0,loginRes,"登录成功");

    }

    @Override
    public BackResponseEntity<LoginRes> codeLogin(CodeLoginReq codeLoginReq){
        String phone = null;
        String code = null;
        Integer role = null;

        if (!ObjectUtils.isEmpty(codeLoginReq.getAccount())) {
            phone =codeLoginReq.getAccount()
                    .trim();
        }
        if (!ObjectUtils.isEmpty(codeLoginReq.getLogincode())) {
            code =codeLoginReq.getLogincode()
                    .trim();
        }


        if(ObjectUtils.isEmpty(phone) || ObjectUtils.isEmpty(code) || ObjectUtils.isEmpty(role)){

            return BackResponseEntity.success(ErrCodeEnum.unknown_4006,"参数缺失");
        }

        Login login = loginMapper.queryByAccount(phone);

        if (ObjectUtils.isEmpty(login)) {
            return BackResponseEntity.success(ErrCodeEnum.unknown_1005, "抱歉，用户不存在!");
        }

        Object verifyDataObject = redisUtil.get(phone + "SMS:users");

        if (!ObjectUtils.isEmpty(verifyDataObject)) {
            String verifyData = (String) verifyDataObject;
            if (!code.equals(verifyData)) {
                return BackResponseEntity.success(ErrCodeEnum.unknown_1001,"验证码错误");
            }
        }else {
            return BackResponseEntity.success(ErrCodeEnum.unknown_1000,"验证码过期");
        }

        String token = UUID.randomUUID()
                .toString();
        LoginRes loginRes = new LoginRes();
        redisUtil.set(token + ":users", JSON.toJSONString(login), 60 * 30);

        loginRes.setToken(token);
        loginRes.setNickname(login.getLoginNickname());
        loginRes.setImg(login.getLoginPic());
        return BackResponseEntity.success(ErrCodeEnum.unknown_0,loginRes,"登录成功");
    }
}

